From ecd3848de9a7f191556419869dc4fc7838c3de79 Mon Sep 17 00:00:00 2001 From: Egor Karavaev Date: Sat, 7 Oct 2017 01:29:36 +0300 Subject: [PATCH] Code cleanup. --- src/smolnetd/main.rs | 2 +- src/smolnetd/scheme/ip.rs | 126 +++---------- src/smolnetd/scheme/mod.rs | 65 ++++--- src/smolnetd/scheme/socket.rs | 336 +++++++++++++++++++++------------- src/smolnetd/scheme/tcp.rs | 157 ++++------------ src/smolnetd/scheme/udp.rs | 155 ++++------------ 6 files changed, 346 insertions(+), 495 deletions(-) diff --git a/src/smolnetd/main.rs b/src/smolnetd/main.rs index 1f78c09590..60cf1df69d 100644 --- a/src/smolnetd/main.rs +++ b/src/smolnetd/main.rs @@ -21,8 +21,8 @@ mod buffer_pool; mod device; mod error; mod logger; -mod scheme; mod port_set; +mod scheme; fn run() -> Result<()> { use syscall::flag::*; diff --git a/src/smolnetd/scheme/ip.rs b/src/smolnetd/scheme/ip.rs index 4edb53b5f9..be014679a4 100644 --- a/src/smolnetd/scheme/ip.rs +++ b/src/smolnetd/scheme/ip.rs @@ -1,31 +1,19 @@ -use super::socket::*; - use smoltcp::socket::{RawPacketBuffer, RawSocket, RawSocketBuffer, SocketHandle}; use smoltcp::wire::{IpProtocol, IpVersion}; -use smoltcp; -use std::io::{Read, Write}; use std::str; -use std::mem; -use std::ops::Deref; -use std::ops::DerefMut; -use syscall::data::TimeSpec; +use syscall::{Error as SyscallError, Result as SyscallResult}; use syscall; use device::NetworkDevice; -use super::Smolnetd; +use super::{Smolnetd, SocketSet}; +use super::socket::{DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme}; pub type IpScheme = SocketScheme>; -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub enum Setting { - ReadTimeout, - WriteTimeout, -} - impl<'a, 'b> SchemeSocket for RawSocket<'a, 'b> { type SchemeDataT = (); type DataT = (); - type SettingT = Setting; + type SettingT = (); fn new_scheme_data() -> Self::SchemeDataT { () @@ -40,70 +28,32 @@ impl<'a, 'b> SchemeSocket for RawSocket<'a, 'b> { } fn get_setting( - file: &SocketFile, - setting: Self::SettingT, - buf: &mut [u8], - ) -> syscall::Result { - let timespec = match (setting, file.read_timeout, file.write_timeout) { - (Setting::ReadTimeout, Some(read_timeout), _) => read_timeout, - (Setting::WriteTimeout, _, Some(write_timeout)) => write_timeout, - _ => { - return Ok(0); - } - }; - - if buf.len() < mem::size_of::() { - Ok(0) - } else { - let count = timespec.deref().read(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - Ok(count) - } + _file: &SocketFile, + _setting: Self::SettingT, + _buf: &mut [u8], + ) -> SyscallResult { + Ok(0) } fn set_setting( - file: &mut SocketFile, - setting: Self::SettingT, - buf: &[u8], - ) -> syscall::Result { - match setting { - Setting::ReadTimeout | Setting::WriteTimeout => { - let (timeout, count) = { - if buf.len() < mem::size_of::() { - (None, 0) - } else { - let mut timespec = TimeSpec::default(); - let count = timespec.deref_mut().write(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - (Some(timespec), count) - } - }; - match setting { - Setting::ReadTimeout => { - file.read_timeout = timeout; - } - Setting::WriteTimeout => { - file.write_timeout = timeout; - } - }; - return Ok(count); - } - } + _file: &mut SocketFile, + _setting: Self::SettingT, + _buf: &[u8], + ) -> SyscallResult { + Ok(0) } fn new_socket( - socket_set: &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, + socket_set: &mut SocketSet, path: &str, uid: u32, _: &mut Self::SchemeDataT, - ) -> syscall::Result<(SocketHandle, Self::DataT)> { + ) -> SyscallResult<(SocketHandle, Self::DataT)> { if uid != 0 { - return Err(syscall::Error::new(syscall::EACCES)); + return Err(SyscallError::new(syscall::EACCES)); } let proto = - u8::from_str_radix(path, 16).or_else(|_| Err(syscall::Error::new(syscall::ENOENT)))?; + u8::from_str_radix(path, 16).or_else(|_| Err(SyscallError::new(syscall::ENOENT)))?; let mut rx_packets = Vec::with_capacity(Smolnetd::SOCKET_BUFFER_SIZE); let mut tx_packets = Vec::with_capacity(Smolnetd::SOCKET_BUFFER_SIZE); @@ -124,7 +74,7 @@ impl<'a, 'b> SchemeSocket for RawSocket<'a, 'b> { Ok((socket_handle, ())) } - fn close_file(&self, _: &SchemeFile, _: &mut Self::SchemeDataT) -> syscall::Result<()> { + fn close_file(&self, _: &SchemeFile, _: &mut Self::SchemeDataT) -> SyscallResult<()> { Ok(()) } @@ -132,14 +82,14 @@ impl<'a, 'b> SchemeSocket for RawSocket<'a, 'b> { &mut self, file: &mut SocketFile, buf: &[u8], - ) -> syscall::Result { + ) -> SyscallResult { if self.can_send() { self.send_slice(buf).expect("Can't send slice"); Ok(buf.len()) } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } @@ -147,47 +97,27 @@ impl<'a, 'b> SchemeSocket for RawSocket<'a, 'b> { &mut self, file: &mut SocketFile, buf: &mut [u8], - ) -> syscall::Result { + ) -> SyscallResult { if self.can_recv() { let length = self.recv_slice(buf).expect("Can't receive slice"); Ok(length) } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } fn dup( - _socket_set: &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, - socket_handle: SocketHandle, + _socket_set: &mut SocketSet, _file: &mut SchemeFile, - fd: usize, - path: &str, + _path: &str, _: &mut Self::SchemeDataT, - ) -> syscall::Result> { - match path { - "write_timeout" => Ok(( - SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::WriteTimeout, - }), - None, - )), - "read_timeout" => Ok(( - SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::ReadTimeout, - }), - None, - )), - _ => Err(syscall::Error::new(syscall::EBADF)), - } + ) -> SyscallResult> { + Err(SyscallError::new(syscall::EBADF)) } - fn fpath(&self, _file: &SchemeFile, buf: &mut [u8]) -> syscall::Result { + fn fpath(&self, _file: &SchemeFile, buf: &mut [u8]) -> SyscallResult { let path = format!("ip:{}", self.ip_protocol()); let path = path.as_bytes(); diff --git a/src/smolnetd/scheme/mod.rs b/src/smolnetd/scheme/mod.rs index 39f3977ac5..a65296521b 100644 --- a/src/smolnetd/scheme/mod.rs +++ b/src/smolnetd/scheme/mod.rs @@ -1,35 +1,38 @@ use netutils::getcfg; -use smoltcp; +use smoltcp::iface::{ArpCache, EthernetInterface, SliceArpCache}; +use smoltcp::socket::SocketSet as SmoltcpSocketSet; +use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, IpEndpoint, Ipv4Address}; use std::cell::RefCell; use std::collections::VecDeque; use std::fs::File; use std::io::{Read, Write}; -use std::mem; +use std::mem::size_of; use std::rc::Rc; use std::str::FromStr; use std::time::Instant; +use syscall::data::TimeSpec; use syscall; use buffer_pool::{Buffer, BufferPool}; use device::NetworkDevice; use error::{Error, Result}; use self::ip::IpScheme; -use self::udp::UdpScheme; use self::tcp::TcpScheme; +use self::udp::UdpScheme; mod ip; mod socket; -mod udp; mod tcp; +mod udp; -type SocketSet = Rc>>; +type SocketSet = SmoltcpSocketSet<'static, 'static, 'static>; pub struct Smolnetd { network_file: Rc>, time_file: File, - iface: smoltcp::iface::EthernetInterface<'static, 'static, 'static, NetworkDevice>, - socket_set: SocketSet, + iface: EthernetInterface<'static, 'static, 'static, NetworkDevice>, + socket_set: Rc>, startup_time: Instant, @@ -54,26 +57,25 @@ impl Smolnetd { tcp_file: File, time_file: File, ) -> Smolnetd { - let arp_cache = smoltcp::iface::SliceArpCache::new(vec![Default::default(); 8]); - let hardware_addr = smoltcp::wire::EthernetAddress::from_str(getcfg("mac").unwrap().trim()) + let arp_cache = SliceArpCache::new(vec![Default::default(); 8]); + let hardware_addr = EthernetAddress::from_str(getcfg("mac").unwrap().trim()) .expect("Can't parse the 'mac' cfg"); - let local_ip = smoltcp::wire::IpAddress::from_str(getcfg("ip").unwrap().trim()) - .expect("Can't parse the 'ip' cfg."); - let protocol_addrs = [smoltcp::wire::IpCidr::new(local_ip, 24)]; - let default_gw = smoltcp::wire::Ipv4Address::from_str(getcfg("ip_router").unwrap().trim()) + let local_ip = + IpAddress::from_str(getcfg("ip").unwrap().trim()).expect("Can't parse the 'ip' cfg."); + let protocol_addrs = [IpCidr::new(local_ip, 24)]; + let default_gw = Ipv4Address::from_str(getcfg("ip_router").unwrap().trim()) .expect("Can't parse the 'ip_router' cfg."); - // trace!("mac {:?} ip {}", hardware_addr, protocol_addrs); let input_queue = Rc::new(RefCell::new(VecDeque::new())); let network_file = Rc::new(RefCell::new(network_file)); let network_device = NetworkDevice::new(Rc::clone(&network_file), Rc::clone(&input_queue)); - let iface = smoltcp::iface::EthernetInterface::new( + let iface = EthernetInterface::new( Box::new(network_device), - Box::new(arp_cache) as Box, + Box::new(arp_cache) as Box, hardware_addr, protocol_addrs, Some(default_gw), ); - let socket_set = Rc::new(RefCell::new(smoltcp::socket::SocketSet::new(vec![]))); + let socket_set = Rc::new(RefCell::new(SocketSet::new(vec![]))); Smolnetd { iface, socket_set: Rc::clone(&socket_set), @@ -97,31 +99,31 @@ impl Smolnetd { pub fn on_ip_scheme_event(&mut self) -> Result> { self.ip_scheme.on_scheme_event()?; - self.poll()?; + let _ = self.poll()?; Ok(None) } pub fn on_udp_scheme_event(&mut self) -> Result> { self.udp_scheme.on_scheme_event()?; - self.poll()?; + let _ = self.poll()?; Ok(None) } pub fn on_tcp_scheme_event(&mut self) -> Result> { self.tcp_scheme.on_scheme_event()?; - self.poll()?; + let _ = self.poll()?; Ok(None) } pub fn on_time_event(&mut self) -> Result> { let timeout = self.poll()?; - self.schedule_timeout(timeout)?; + self.schedule_time_event(timeout)?; Ok(None) } - fn schedule_timeout(&mut self, timeout: i64) -> Result<()> { - let mut time = syscall::data::TimeSpec::default(); - if self.time_file.read(&mut time)? < mem::size_of::() { + fn schedule_time_event(&mut self, timeout: i64) -> Result<()> { + let mut time = TimeSpec::default(); + if self.time_file.read(&mut time)? < size_of::() { return Err(Error::from_syscall_error( syscall::Error::new(syscall::EBADF), "Can't read current time", @@ -215,3 +217,18 @@ fn post_fevent(scheme_file: &mut File, fd: usize, event: usize, data_len: usize) .map(|_| ()) .map_err(|e| Error::from_io_error(e, "failed to post fevent")) } + +fn parse_endpoint(socket: &str) -> IpEndpoint { + let mut socket_parts = socket.split(':'); + let host = IpAddress::Ipv4( + Ipv4Address::from_str(socket_parts.next().unwrap_or("")) + .unwrap_or_else(|_| Ipv4Address::new(0, 0, 0, 0)), + ); + + let port = socket_parts + .next() + .unwrap_or("") + .parse::() + .unwrap_or(0); + IpEndpoint::new(host, port) +} diff --git a/src/smolnetd/scheme/socket.rs b/src/smolnetd/scheme/socket.rs index 7d5b3ec05e..b36af6e1d7 100644 --- a/src/smolnetd/scheme/socket.rs +++ b/src/smolnetd/scheme/socket.rs @@ -1,25 +1,29 @@ use smoltcp::socket::{AnySocket, SocketHandle}; -use smoltcp; +use std::cell::RefCell; use std::collections::BTreeMap; use std::fs::File; use std::io::{Read, Write}; -use std::str; use std::marker::PhantomData; -use syscall::SchemeMut; +use std::mem; +use std::ops::Deref; +use std::ops::DerefMut; +use std::rc::Rc; +use std::str; use syscall::data::TimeSpec; +use syscall::{Error as SyscallError, Packet as SyscallPacket, Result as SyscallResult, SchemeMut}; use syscall; use error::{Error, Result}; -use super::SocketSet; -use super::post_fevent; +use super::{SocketSet, post_fevent}; pub struct SocketFile { pub flags: usize, + pub data: DataT, + events: usize, socket_handle: SocketHandle, - pub data: DataT, - pub read_timeout: Option, - pub write_timeout: Option, + read_timeout: Option, + write_timeout: Option, } impl SocketFile { @@ -46,10 +50,18 @@ impl SocketFile { } } -pub struct SettingFile { - pub fd: usize, - pub socket_handle: SocketHandle, - pub setting: SettingT, +#[derive(Copy, Clone)] +enum Setting { + Ttl, + ReadTimeout, + WriteTimeout, + #[allow(dead_code)] Other(SettingT), +} + +pub struct SettingFile { + fd: usize, + socket_handle: SocketHandle, + setting: Setting, } pub enum SchemeFile @@ -64,7 +76,7 @@ impl SchemeFile where SocketT: SchemeSocket, { - fn socket_handle(&self) -> SocketHandle { + pub fn socket_handle(&self) -> SocketHandle { match *self { SchemeFile::Socket(SocketFile { socket_handle, .. }) | SchemeFile::Setting(SettingFile { socket_handle, .. }) => socket_handle, @@ -75,14 +87,17 @@ where #[derive(Default, Clone)] struct WaitHandle { until: Option, - packet: syscall::Packet, + packet: SyscallPacket, } type WaitQueue = Vec; type WaitQueueMap = BTreeMap; -pub type DupResult = (SchemeFile, Option<(SocketHandle, T::DataT)>); +pub type DupResult = ( + SchemeFile, + Option<(SocketHandle, ::DataT)>, +); pub trait SchemeSocket where @@ -97,30 +112,30 @@ where fn can_send(&self) -> bool; fn can_recv(&self) -> bool; - fn get_setting(&SocketFile, Self::SettingT, &mut [u8]) -> syscall::Result; - fn set_setting(&mut SocketFile, Self::SettingT, &[u8]) -> syscall::Result; + fn get_setting(&SocketFile, Self::SettingT, &mut [u8]) -> SyscallResult; + fn set_setting(&mut SocketFile, Self::SettingT, &[u8]) -> SyscallResult; fn new_socket( - &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, + &mut SocketSet, &str, u32, &mut Self::SchemeDataT, - ) -> syscall::Result<(SocketHandle, Self::DataT)>; - fn close_file(&self, &SchemeFile, &mut Self::SchemeDataT) -> syscall::Result<()>; + ) -> SyscallResult<(SocketHandle, Self::DataT)>; - fn write_buf(&mut self, &mut SocketFile, buf: &[u8]) -> syscall::Result; - fn read_buf(&mut self, &mut SocketFile, buf: &mut [u8]) -> syscall::Result; + fn close_file(&self, &SchemeFile, &mut Self::SchemeDataT) -> SyscallResult<()>; - fn fpath(&self, &SchemeFile, &mut [u8]) -> syscall::Result; + fn write_buf(&mut self, &mut SocketFile, buf: &[u8]) -> SyscallResult; + + fn read_buf(&mut self, &mut SocketFile, buf: &mut [u8]) -> SyscallResult; + + fn fpath(&self, &SchemeFile, &mut [u8]) -> SyscallResult; fn dup( - &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, - SocketHandle, + &mut SocketSet, &mut SchemeFile, - usize, &str, &mut Self::SchemeDataT, - ) -> syscall::Result>; + ) -> SyscallResult>; } pub struct SocketScheme @@ -128,8 +143,8 @@ where SocketT: SchemeSocket + AnySocket<'static, 'static>, { next_fd: usize, - fds: BTreeMap>, - socket_set: SocketSet, + files: BTreeMap>, + socket_set: Rc>, scheme_file: File, wait_queue_map: WaitQueueMap, scheme_data: SocketT::SchemeDataT, @@ -140,10 +155,10 @@ impl SocketScheme where SocketT: SchemeSocket + AnySocket<'static, 'static>, { - pub fn new(socket_set: SocketSet, scheme_file: File) -> SocketScheme { + pub fn new(socket_set: Rc>, scheme_file: File) -> SocketScheme { SocketScheme { next_fd: 1, - fds: BTreeMap::new(), + files: BTreeMap::new(), socket_set, scheme_data: SocketT::new_scheme_data(), scheme_file, @@ -154,7 +169,7 @@ where pub fn on_scheme_event(&mut self) -> Result> { loop { - let mut packet = syscall::Packet::default(); + let mut packet = SyscallPacket::default(); if self.scheme_file.read(&mut packet)? == 0 { break; } @@ -172,12 +187,12 @@ where pub fn notify_sockets(&mut self) -> Result<()> { // Notify non-blocking sockets - for (&fd, handle) in &self.fds { + for (&fd, file) in &self.files { if let SchemeFile::Socket(SocketFile { socket_handle, events, .. - }) = *handle + }) = *file { let mut socket_set = self.socket_set.borrow_mut(); let socket = socket_set.get::(socket_handle); @@ -243,7 +258,6 @@ where } } } else { - trace!("Waking up {} with {}", packet.b, packet.a); self.scheme_file.write_all(&packet)?; } } @@ -255,13 +269,12 @@ where Ok(()) } - fn move_handle_to_new_socket_handle( + fn move_file_to_new_socket_handle( wait_queue_map: &mut WaitQueueMap, fd: usize, from: SocketHandle, to: SocketHandle, - ) -> syscall::Result<()> { - trace!("Moving {} from {:?} to {:?}", fd, from, to); + ) -> SyscallResult<()> { let mut to_move = vec![]; if let Some(wait_queue) = wait_queue_map.get_mut(&from) { @@ -277,7 +290,7 @@ where Ok(()) } - fn handle_block(&mut self, mut packet: syscall::Packet) -> Result<()> { + fn handle_block(&mut self, mut packet: SyscallPacket) -> Result<()> { let syscall_result = self.try_handle_block(&mut packet); if let Err(syscall_error) = syscall_result { packet.a = (-syscall_error.errno) as usize; @@ -291,21 +304,21 @@ where } } - fn try_handle_block(&mut self, packet: &mut syscall::Packet) -> syscall::Result<()> { + fn try_handle_block(&mut self, packet: &mut SyscallPacket) -> SyscallResult<()> { let fd = packet.b; let (socket_handle, read_timeout, write_timeout) = { - let handle = self.fds + let file = self.files .get(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; - if let SchemeFile::Socket(ref scheme_file) = *handle { + if let SchemeFile::Socket(ref scheme_file) = *file { Ok(( scheme_file.socket_handle, scheme_file.read_timeout, scheme_file.write_timeout, )) } else { - Err(syscall::Error::new(syscall::EBADF)) + Err(SyscallError::new(syscall::EBADF)) } }?; @@ -336,38 +349,83 @@ where fn get_setting( &mut self, fd: usize, - setting: SocketT::SettingT, + setting: Setting, buf: &mut [u8], - ) -> syscall::Result { - let handle = self.fds + ) -> SyscallResult { + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; - let handle = match *handle { - SchemeFile::Socket(ref mut handle) => handle, + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; + let file = match *file { + SchemeFile::Socket(ref mut file) => file, _ => { - return Err(syscall::Error::new(syscall::EBADF)); + return Err(SyscallError::new(syscall::EBADF)); } }; - SocketT::get_setting(handle, setting, buf) + if let Setting::Other(setting) = setting { + SocketT::get_setting(file, setting, buf) + } else { + let timespec = match (setting, file.read_timeout, file.write_timeout) { + (Setting::ReadTimeout, Some(read_timeout), _) => read_timeout, + (Setting::WriteTimeout, _, Some(write_timeout)) => write_timeout, + _ => { + return Ok(0); + } + }; + + if buf.len() < mem::size_of::() { + Ok(0) + } else { + let count = timespec.deref().read(buf).map_err(|err| { + SyscallError::new(err.raw_os_error().unwrap_or(syscall::EIO)) + })?; + Ok(count) + } + } } fn update_setting( &mut self, fd: usize, - setting: SocketT::SettingT, + setting: Setting, buf: &[u8], - ) -> syscall::Result { - let handle = self.fds + ) -> SyscallResult { + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; - let handle = match *handle { - SchemeFile::Socket(ref mut handle) => handle, + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; + let file = match *file { + SchemeFile::Socket(ref mut file) => file, _ => { - return Err(syscall::Error::new(syscall::EBADF)); + return Err(SyscallError::new(syscall::EBADF)); } }; - SocketT::set_setting(handle, setting, buf) + match setting { + Setting::ReadTimeout | Setting::WriteTimeout => { + let (timeout, count) = { + if buf.len() < mem::size_of::() { + (None, 0) + } else { + let mut timespec = TimeSpec::default(); + let count = timespec.deref_mut().write(buf).map_err(|err| { + SyscallError::new(err.raw_os_error().unwrap_or(syscall::EIO)) + })?; + (Some(timespec), count) + } + }; + match setting { + Setting::ReadTimeout => { + file.read_timeout = timeout; + } + Setting::WriteTimeout => { + file.write_timeout = timeout; + } + _ => {} + }; + Ok(count) + } + Setting::Ttl => Ok(0), + Setting::Other(setting) => SocketT::set_setting(file, setting, buf), + } } } @@ -375,9 +433,8 @@ impl syscall::SchemeMut for SocketScheme where SocketT: SchemeSocket + AnySocket<'static, 'static>, { - fn open(&mut self, url: &[u8], flags: usize, uid: u32, _gid: u32) -> syscall::Result { - let path = str::from_utf8(url).or_else(|_| Err(syscall::Error::new(syscall::EINVAL)))?; - trace!("open {}", path); + fn open(&mut self, url: &[u8], flags: usize, uid: u32, _gid: u32) -> SyscallResult { + let path = str::from_utf8(url).or_else(|_| Err(SyscallError::new(syscall::EINVAL)))?; let (socket_handle, data) = SocketT::new_socket( &mut self.socket_set.borrow_mut(), @@ -388,7 +445,7 @@ where let id = self.next_fd; - self.fds.insert( + self.files.insert( id, SchemeFile::Socket(SocketFile { flags, @@ -403,15 +460,14 @@ where Ok(id) } - fn close(&mut self, fd: usize) -> syscall::Result { - trace!("close {}", fd); + fn close(&mut self, fd: usize) -> SyscallResult { let socket_handle = { - let handle = self.fds + let file = self.files .get(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; - handle.socket_handle() + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; + file.socket_handle() }; - let scheme_file = self.fds.remove(&fd); + let scheme_file = self.files.remove(&fd); let mut socket_set = self.socket_set.borrow_mut(); if let Some(scheme_file) = scheme_file { let socket = socket_set.get::(socket_handle); @@ -421,7 +477,7 @@ where if let Some(ref mut wait_queue) = self.wait_queue_map.get_mut(&socket_handle) { wait_queue.retain( |&WaitHandle { - packet: syscall::Packet { a, .. }, + packet: SyscallPacket { a, .. }, .. }| a != fd, ); @@ -438,143 +494,165 @@ where Ok(0) } - fn write(&mut self, fd: usize, buf: &[u8]) -> syscall::Result { + fn write(&mut self, fd: usize, buf: &[u8]) -> SyscallResult { let (fd, setting) = { - let handle = self.fds + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; - match *handle { + match *file { SchemeFile::Setting(ref setting_handle) => { (setting_handle.fd, setting_handle.setting) } - SchemeFile::Socket(ref mut handle) => { + SchemeFile::Socket(ref mut file) => { let mut socket_set = self.socket_set.borrow_mut(); - let mut socket = socket_set.get::(handle.socket_handle); - - return ::write_buf(&mut socket, handle, buf); + let mut socket = socket_set.get::(file.socket_handle); + return SocketT::write_buf(&mut socket, file, buf); } } }; self.update_setting(fd, setting, buf) } - fn read(&mut self, fd: usize, buf: &mut [u8]) -> syscall::Result { + fn read(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult { let (fd, setting) = { - let handle = self.fds + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; - match *handle { + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; + match *file { SchemeFile::Setting(ref setting_handle) => { (setting_handle.fd, setting_handle.setting) } - SchemeFile::Socket(ref mut handle) => { + SchemeFile::Socket(ref mut file) => { let mut socket_set = self.socket_set.borrow_mut(); - let mut socket = socket_set.get::(handle.socket_handle); - return ::read_buf(&mut socket, handle, buf); + let mut socket = socket_set.get::(file.socket_handle); + return SocketT::read_buf(&mut socket, file, buf); } } }; self.get_setting(fd, setting, buf) } - fn dup(&mut self, fd: usize, buf: &[u8]) -> syscall::Result { - let path = str::from_utf8(buf).or_else(|_| Err(syscall::Error::new(syscall::EINVAL)))?; + fn dup(&mut self, fd: usize, buf: &[u8]) -> SyscallResult { + let path = str::from_utf8(buf).or_else(|_| Err(SyscallError::new(syscall::EINVAL)))?; let new_file = { - let handle = self.fds + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; - let socket_handle = handle.socket_handle(); + let socket_handle = file.socket_handle(); - let (new_handle, update_with) = SocketT::dup( - &mut self.socket_set.borrow_mut(), - socket_handle, - handle, - fd, - path, - &mut self.scheme_data, - )?; + let (new_handle, update_with) = match path { + "ttl" => ( + SchemeFile::Setting(SettingFile { + socket_handle, + fd, + setting: Setting::Ttl, + }), + None, + ), + "read_timeout" => ( + SchemeFile::Setting(SettingFile { + socket_handle, + fd, + setting: Setting::ReadTimeout, + }), + None, + ), + "write_timeout" => ( + SchemeFile::Setting(SettingFile { + socket_handle, + fd, + setting: Setting::WriteTimeout, + }), + None, + ), + _ => SocketT::dup( + &mut self.socket_set.borrow_mut(), + file, + path, + &mut self.scheme_data, + )?, + }; if let Some((socket_handle, data)) = update_with { - if let SchemeFile::Socket(ref mut handle) = *handle { - trace!("Updating {} to a new socket handle {:?}", fd, socket_handle); - Self::move_handle_to_new_socket_handle( + if let SchemeFile::Socket(ref mut file) = *file { + Self::move_file_to_new_socket_handle( &mut self.wait_queue_map, fd, - handle.socket_handle, + file.socket_handle, socket_handle, )?; - handle.socket_handle = socket_handle; - handle.data = data; + file.socket_handle = socket_handle; + file.data = data; } else { - self.socket_set.borrow_mut().retain(handle.socket_handle()); + self.socket_set.borrow_mut().retain(file.socket_handle()); } } else { - self.socket_set.borrow_mut().retain(handle.socket_handle()); + self.socket_set.borrow_mut().retain(file.socket_handle()); } new_handle }; let id = self.next_fd; - self.fds.insert(id, new_file); + self.files.insert(id, new_file); self.next_fd += 1; Ok(id) } - fn fevent(&mut self, fd: usize, events: usize) -> syscall::Result { - let handle = self.fds + fn fevent(&mut self, fd: usize, events: usize) -> SyscallResult { + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; - match *handle { - SchemeFile::Setting(_) => Err(syscall::Error::new(syscall::EBADF)), - SchemeFile::Socket(ref mut handle) => { - handle.events = events; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; + match *file { + SchemeFile::Setting(_) => Err(SyscallError::new(syscall::EBADF)), + SchemeFile::Socket(ref mut file) => { + file.events = events; Ok(fd) } } } - fn fsync(&mut self, fd: usize) -> syscall::Result { + fn fsync(&mut self, fd: usize) -> SyscallResult { { - let _handle = self.fds + let _file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; } Ok(0) // TODO Implement fsyncing // self.0.network_fsync() } - fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> syscall::Result { - let handle = self.fds + fn fpath(&mut self, fd: usize, buf: &mut [u8]) -> SyscallResult { + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; let mut socket_set = self.socket_set.borrow_mut(); - let socket = socket_set.get::(handle.socket_handle()); + let socket = socket_set.get::(file.socket_handle()); - socket.fpath(handle, buf) + socket.fpath(file, buf) } - fn fcntl(&mut self, fd: usize, cmd: usize, arg: usize) -> syscall::Result { - let handle = self.fds + fn fcntl(&mut self, fd: usize, cmd: usize, arg: usize) -> SyscallResult { + let file = self.files .get_mut(&fd) - .ok_or_else(|| syscall::Error::new(syscall::EBADF))?; + .ok_or_else(|| SyscallError::new(syscall::EBADF))?; - if let SchemeFile::Socket(ref mut socket_file) = *handle { + if let SchemeFile::Socket(ref mut socket_file) = *file { match cmd { syscall::F_GETFL => Ok(socket_file.flags), syscall::F_SETFL => { socket_file.flags = arg & !syscall::O_ACCMODE; Ok(0) } - _ => Err(syscall::Error::new(syscall::EINVAL)), + _ => Err(SyscallError::new(syscall::EINVAL)), } } else { - Err(syscall::Error::new(syscall::EBADF)) + Err(SyscallError::new(syscall::EBADF)) } } } diff --git a/src/smolnetd/scheme/tcp.rs b/src/smolnetd/scheme/tcp.rs index 46e6de4173..1ce10f3020 100644 --- a/src/smolnetd/scheme/tcp.rs +++ b/src/smolnetd/scheme/tcp.rs @@ -1,32 +1,18 @@ -use super::socket::*; - use smoltcp::socket::{SocketHandle, TcpSocket, TcpSocketBuffer}; -use smoltcp::wire::{IpAddress, IpEndpoint, Ipv4Address}; -use smoltcp; -use std::io::{Read, Write}; -use std::str::FromStr; use std::str; -use std::mem; -use std::ops::Deref; -use std::ops::DerefMut; -use syscall::data::TimeSpec; +use syscall::{Error as SyscallError, Result as SyscallResult}; use syscall; use port_set::PortSet; +use super::socket::{DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme}; +use super::{parse_endpoint, SocketSet}; pub type TcpScheme = SocketScheme>; -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub enum Setting { - Ttl, - ReadTimeout, - WriteTimeout, -} - impl<'a> SchemeSocket for TcpSocket<'a> { type SchemeDataT = PortSet; type DataT = (); - type SettingT = Setting; + type SettingT = (); fn new_scheme_data() -> Self::SchemeDataT { PortSet::new(49_152u16, 65_535u16).expect("Wrong TCP port numbers") @@ -41,77 +27,34 @@ impl<'a> SchemeSocket for TcpSocket<'a> { } fn get_setting( - file: &SocketFile, - setting: Self::SettingT, - buf: &mut [u8], - ) -> syscall::Result { - trace!("TCP get setting {:?}", setting); - let timespec = match (setting, file.read_timeout, file.write_timeout) { - (Setting::ReadTimeout, Some(read_timeout), _) => read_timeout, - (Setting::WriteTimeout, _, Some(write_timeout)) => write_timeout, - _ => { - return Ok(0); - } - }; - - if buf.len() < mem::size_of::() { - Ok(0) - } else { - let count = timespec.deref().read(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - Ok(count) - } + _file: &SocketFile, + _setting: Self::SettingT, + _buf: &mut [u8], + ) -> SyscallResult { + Ok(0) } fn set_setting( - file: &mut SocketFile, - setting: Self::SettingT, - buf: &[u8], - ) -> syscall::Result { - trace!("TCP set setting {:?}", setting); - match setting { - Setting::ReadTimeout | Setting::WriteTimeout => { - let (timeout, count) = { - if buf.len() < mem::size_of::() { - (None, 0) - } else { - let mut timespec = TimeSpec::default(); - let count = timespec.deref_mut().write(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - (Some(timespec), count) - } - }; - match setting { - Setting::ReadTimeout => { - file.read_timeout = timeout; - } - Setting::WriteTimeout => { - file.write_timeout = timeout; - } - _ => {} - }; - return Ok(count); - } - Setting::Ttl => {} - } + _file: &mut SocketFile, + _setting: Self::SettingT, + _buf: &[u8], + ) -> SyscallResult { Ok(0) } fn new_socket( - socket_set: &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, + socket_set: &mut SocketSet, path: &str, uid: u32, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result<(SocketHandle, Self::DataT)> { + ) -> SyscallResult<(SocketHandle, Self::DataT)> { trace!("TCP open {}", path); let mut parts = path.split('/'); let remote_endpoint = parse_endpoint(parts.next().unwrap_or("")); let mut local_endpoint = parse_endpoint(parts.next().unwrap_or("")); if local_endpoint.port > 0 && local_endpoint.port <= 1024 && uid != 0 { - return Err(syscall::Error::new(syscall::EACCES)); + return Err(SyscallError::new(syscall::EACCES)); } let rx_packets = vec![0; 65_535]; @@ -123,9 +66,9 @@ impl<'a> SchemeSocket for TcpSocket<'a> { if local_endpoint.port == 0 { local_endpoint.port = port_set .get_port() - .ok_or_else(|| syscall::Error::new(syscall::EINVAL))?; + .ok_or_else(|| SyscallError::new(syscall::EINVAL))?; } else if !port_set.claim_port(local_endpoint.port) { - return Err(syscall::Error::new(syscall::EADDRINUSE)); + return Err(SyscallError::new(syscall::EADDRINUSE)); } let socket_handle = socket_set.add(socket); @@ -151,7 +94,7 @@ impl<'a> SchemeSocket for TcpSocket<'a> { &self, file: &SchemeFile, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result<()> { + ) -> SyscallResult<()> { if let SchemeFile::Socket(_) = *file { port_set.release_port(self.local_endpoint().port); } @@ -162,16 +105,16 @@ impl<'a> SchemeSocket for TcpSocket<'a> { &mut self, file: &mut SocketFile, buf: &[u8], - ) -> syscall::Result { + ) -> SyscallResult { if !self.is_active() { - Err(syscall::Error::new(syscall::ENOTCONN)) + Err(SyscallError::new(syscall::ENOTCONN)) } else if self.can_send() { self.send_slice(buf).expect("Can't send slice"); Ok(buf.len()) } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } @@ -179,51 +122,36 @@ impl<'a> SchemeSocket for TcpSocket<'a> { &mut self, file: &mut SocketFile, buf: &mut [u8], - ) -> syscall::Result { + ) -> SyscallResult { if !self.is_active() { - Err(syscall::Error::new(syscall::ENOTCONN)) + Err(SyscallError::new(syscall::ENOTCONN)) } else if self.can_recv() { let length = self.recv_slice(buf).expect("Can't receive slice"); Ok(length) } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } fn dup( - socket_set: &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, - socket_handle: SocketHandle, + socket_set: &mut SocketSet, file: &mut SchemeFile, - fd: usize, path: &str, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result> { + ) -> SyscallResult> { + let socket_handle = file.socket_handle(); + let (is_active, local_endpoint) = { let socket = socket_set.get::(socket_handle); (socket.is_active(), socket.local_endpoint()) }; - let handle = match path { - "ttl" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::Ttl, - }), - "read_timeout" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::ReadTimeout, - }), - "write_timeout" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::WriteTimeout, - }), + let file = match path { "listen" => if let SchemeFile::Socket(ref tcp_handle) = *file { if !is_active { - return Err(syscall::Error::new(syscall::EWOULDBLOCK)); + return Err(SyscallError::new(syscall::EWOULDBLOCK)); } trace!("TCP creating new listening socket"); let new_handle = SchemeFile::Socket(tcp_handle.clone_with_data(())); @@ -243,7 +171,7 @@ impl<'a> SchemeSocket for TcpSocket<'a> { port_set.acquire_port(local_endpoint.port); return Ok((new_handle, Some((new_socket_handle, ())))); } else { - return Err(syscall::Error::new(syscall::EBADF)); + return Err(SyscallError::new(syscall::EBADF)); }, _ => { trace!("TCP dup unknown {}", path); @@ -255,14 +183,14 @@ impl<'a> SchemeSocket for TcpSocket<'a> { } }; - if let SchemeFile::Socket(_) = handle { + if let SchemeFile::Socket(_) = file { port_set.acquire_port(local_endpoint.port); } - Ok((handle, None)) + Ok((file, None)) } - fn fpath(&self, _: &SchemeFile, buf: &mut [u8]) -> syscall::Result { + fn fpath(&self, _: &SchemeFile, buf: &mut [u8]) -> SyscallResult { let path = format!("tcp:{}/{}", self.remote_endpoint(), self.local_endpoint()); let path = path.as_bytes(); @@ -275,18 +203,3 @@ impl<'a> SchemeSocket for TcpSocket<'a> { Ok(i) } } - -fn parse_endpoint(socket: &str) -> IpEndpoint { - let mut socket_parts = socket.split(':'); - let host = IpAddress::Ipv4( - Ipv4Address::from_str(socket_parts.next().unwrap_or("")) - .unwrap_or_else(|_| Ipv4Address::new(0, 0, 0, 0)), - ); - - let port = socket_parts - .next() - .unwrap_or("") - .parse::() - .unwrap_or(0); - IpEndpoint::new(host, port) -} diff --git a/src/smolnetd/scheme/udp.rs b/src/smolnetd/scheme/udp.rs index 9641984b7d..87f65b9bdb 100644 --- a/src/smolnetd/scheme/udp.rs +++ b/src/smolnetd/scheme/udp.rs @@ -1,34 +1,20 @@ -use super::socket::*; - use smoltcp::socket::{SocketHandle, UdpPacketBuffer, UdpSocket, UdpSocketBuffer}; -use smoltcp::wire::{IpAddress, IpEndpoint, Ipv4Address}; -use smoltcp; -use std::io::{Read, Write}; -use std::str::FromStr; +use smoltcp::wire::IpEndpoint; use std::str; -use std::mem; -use std::ops::Deref; -use std::ops::DerefMut; -use syscall::data::TimeSpec; +use syscall::{Error as SyscallError, Result as SyscallResult}; use syscall; use device::NetworkDevice; -use super::Smolnetd; use port_set::PortSet; +use super::socket::{DupResult, SchemeFile, SchemeSocket, SocketFile, SocketScheme}; +use super::{parse_endpoint, Smolnetd, SocketSet}; pub type UdpScheme = SocketScheme>; -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub enum Setting { - Ttl, - ReadTimeout, - WriteTimeout, -} - impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { type SchemeDataT = PortSet; type DataT = IpEndpoint; - type SettingT = Setting; + type SettingT = (); fn new_scheme_data() -> Self::SchemeDataT { PortSet::new(49_152u16, 65_535u16).expect("Wrong UDP port numbers") @@ -43,75 +29,33 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { } fn get_setting( - file: &SocketFile, - setting: Self::SettingT, - buf: &mut [u8], - ) -> syscall::Result { - let timespec = match (setting, file.read_timeout, file.write_timeout) { - (Setting::ReadTimeout, Some(read_timeout), _) => read_timeout, - (Setting::WriteTimeout, _, Some(write_timeout)) => write_timeout, - _ => { - return Ok(0); - } - }; - - if buf.len() < mem::size_of::() { - Ok(0) - } else { - let count = timespec.deref().read(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - Ok(count) - } + _file: &SocketFile, + _setting: Self::SettingT, + _buf: &mut [u8], + ) -> SyscallResult { + Ok(0) } fn set_setting( - file: &mut SocketFile, - setting: Self::SettingT, - buf: &[u8], - ) -> syscall::Result { - match setting { - Setting::ReadTimeout | Setting::WriteTimeout => { - let (timeout, count) = { - if buf.len() < mem::size_of::() { - (None, 0) - } else { - let mut timespec = TimeSpec::default(); - let count = timespec.deref_mut().write(buf).map_err(|err| { - syscall::Error::new(err.raw_os_error().unwrap_or(syscall::EIO)) - })?; - (Some(timespec), count) - } - }; - trace!("Setting {:?} to {:?}", setting, timeout); - match setting { - Setting::ReadTimeout => { - file.read_timeout = timeout; - } - Setting::WriteTimeout => { - file.write_timeout = timeout; - } - _ => {} - }; - return Ok(count); - } - Setting::Ttl => {} - } + _file: &mut SocketFile, + _setting: Self::SettingT, + _buf: &[u8], + ) -> SyscallResult { Ok(0) } fn new_socket( - socket_set: &mut smoltcp::socket::SocketSet<'static, 'static, 'static>, + socket_set: &mut SocketSet, path: &str, uid: u32, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result<(SocketHandle, Self::DataT)> { + ) -> SyscallResult<(SocketHandle, Self::DataT)> { let mut parts = path.split('/'); let remote_endpoint = parse_endpoint(parts.next().unwrap_or("")); let mut local_endpoint = parse_endpoint(parts.next().unwrap_or("")); if local_endpoint.port > 0 && local_endpoint.port <= 1024 && uid != 0 { - return Err(syscall::Error::new(syscall::EACCES)); + return Err(SyscallError::new(syscall::EACCES)); } let mut rx_packets = Vec::with_capacity(Smolnetd::SOCKET_BUFFER_SIZE); @@ -127,9 +71,9 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { if local_endpoint.port == 0 { local_endpoint.port = port_set .get_port() - .ok_or_else(|| syscall::Error::new(syscall::EINVAL))?; + .ok_or_else(|| SyscallError::new(syscall::EINVAL))?; } else if !port_set.claim_port(local_endpoint.port) { - return Err(syscall::Error::new(syscall::EADDRINUSE)); + return Err(SyscallError::new(syscall::EADDRINUSE)); } let socket_handle = socket_set.add(udp_socket); @@ -146,7 +90,7 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { &self, file: &SchemeFile, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result<()> { + ) -> SyscallResult<()> { if let SchemeFile::Socket(_) = *file { port_set.release_port(self.endpoint().port); } @@ -157,9 +101,9 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { &mut self, file: &mut SocketFile, buf: &[u8], - ) -> syscall::Result { + ) -> SyscallResult { if !file.data.is_specified() { - return Err(syscall::Error::new(syscall::EADDRNOTAVAIL)); + return Err(SyscallError::new(syscall::EADDRNOTAVAIL)); } if self.can_send() { self.send_slice(buf, file.data).expect("Can't send slice"); @@ -167,7 +111,7 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } @@ -175,41 +119,25 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { &mut self, file: &mut SocketFile, buf: &mut [u8], - ) -> syscall::Result { + ) -> SyscallResult { if self.can_recv() { let (length, _) = self.recv_slice(buf).expect("Can't receive slice"); Ok(length) } else if file.flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK { Ok(0) } else { - Err(syscall::Error::new(syscall::EWOULDBLOCK)) + Err(SyscallError::new(syscall::EWOULDBLOCK)) } } fn dup( - socket_set: &mut smoltcp::socket::SocketSet, - socket_handle: SocketHandle, + socket_set: &mut SocketSet, file: &mut SchemeFile, - fd: usize, path: &str, port_set: &mut Self::SchemeDataT, - ) -> syscall::Result> { - let handle = match path { - "ttl" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::Ttl, - }), - "read_timeout" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::ReadTimeout, - }), - "write_timeout" => SchemeFile::Setting(SettingFile { - socket_handle, - fd, - setting: Setting::WriteTimeout, - }), + ) -> SyscallResult> { + let socket_handle = file.socket_handle(); + let file = match path { _ => { let remote_endpoint = parse_endpoint(path); if let SchemeFile::Socket(ref udp_handle) = *file { @@ -231,15 +159,15 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { socket.endpoint() }; - if let SchemeFile::Socket(_) = handle { + if let SchemeFile::Socket(_) = file { port_set.acquire_port(endpoint.port); } - Ok((handle, None)) + Ok((file, None)) } - fn fpath(&self, file: &SchemeFile, buf: &mut [u8]) -> syscall::Result { - if let &SchemeFile::Socket(ref socket_file) = file { + fn fpath(&self, file: &SchemeFile, buf: &mut [u8]) -> SyscallResult { + if let SchemeFile::Socket(ref socket_file) = *file { let path = format!("udp:{}/{}", socket_file.data, self.endpoint()); let path = path.as_bytes(); @@ -251,22 +179,7 @@ impl<'a, 'b> SchemeSocket for UdpSocket<'a, 'b> { Ok(i) } else { - Err(syscall::Error::new(syscall::EBADF)) + Err(SyscallError::new(syscall::EBADF)) } } } - -fn parse_endpoint(socket: &str) -> IpEndpoint { - let mut socket_parts = socket.split(':'); - let host = IpAddress::Ipv4( - Ipv4Address::from_str(socket_parts.next().unwrap_or("")) - .unwrap_or_else(|_| Ipv4Address::new(0, 0, 0, 0)), - ); - - let port = socket_parts - .next() - .unwrap_or("") - .parse::() - .unwrap_or(0); - IpEndpoint::new(host, port) -}