vinzenz/redox
0
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Add settings for TCP

Browse source
This commit is contained in:
Jeremy Soller 2017-01-03 12:40:55 -07:00
parent bef3884d2a
commit e3635f37f6
1 changed files with 419 additions and 300 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

719
schemes/tcpd/src/main.rs
View file

@ -9,12 +9,13 @@ use std::cell::RefCell;
use std::fs::File; use std::fs::File;
use std::io::{self, Read, Write}; use std::io::{self, Read, Write};
use std::{mem, slice, str}; use std::{mem, slice, str};
use std::ops::{Deref, DerefMut};
use std::os::unix::io::FromRawFd; use std::os::unix::io::FromRawFd;
use std::rc::Rc; use std::rc::Rc;
use event::EventQueue; use event::EventQueue;
use netutils::{n16, n32, Ipv4, Ipv4Addr, Ipv4Header, Tcp, TcpHeader, Checksum, TCP_FIN, TCP_SYN, TCP_RST, TCP_PSH, TCP_ACK}; use netutils::{n16, n32, Ipv4, Ipv4Addr, Ipv4Header, Tcp, TcpHeader, Checksum, TCP_FIN, TCP_SYN, TCP_RST, TCP_PSH, TCP_ACK};
use syscall::data::Packet; use syscall::data::{Packet, TimeSpec};
use syscall::error::{Error, Result, EACCES, EADDRINUSE, EBADF, EIO, EINVAL, EISCONN, EMSGSIZE, ENOTCONN, EWOULDBLOCK}; use syscall::error::{Error, Result, EACCES, EADDRINUSE, EBADF, EIO, EINVAL, EISCONN, EMSGSIZE, ENOTCONN, EWOULDBLOCK};
use syscall::flag::{EVENT_READ, F_GETFL, F_SETFL, O_ACCMODE, O_CREAT, O_RDWR, O_NONBLOCK}; use syscall::flag::{EVENT_READ, F_GETFL, F_SETFL, O_ACCMODE, O_CREAT, O_RDWR, O_NONBLOCK};
use syscall::scheme::SchemeMut; use syscall::scheme::SchemeMut;
@ -41,11 +42,14 @@ enum State {
Closed Closed
} }
struct Handle { struct TcpHandle {
local: (Ipv4Addr, u16), local: (Ipv4Addr, u16),
remote: (Ipv4Addr, u16), remote: (Ipv4Addr, u16),
flags: usize, flags: usize,
events: usize, events: usize,
read_timeout: Option<TimeSpec>,
write_timeout: Option<TimeSpec>,
ttl: u8,
state: State, state: State,
seq: u32, seq: u32,
ack: u32, ack: u32,
@ -55,7 +59,7 @@ struct Handle {
todo_write: VecDeque<Packet>, todo_write: VecDeque<Packet>,
} }
impl Handle { impl TcpHandle {
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.remote.0 != Ipv4Addr::NULL && self.remote.1 != 0 self.remote.0 != Ipv4Addr::NULL && self.remote.1 != 0
} }
@ -100,7 +104,7 @@ impl Handle {
len: n16::new((data.len() + mem::size_of::<Ipv4Header>()) as u16), len: n16::new((data.len() + mem::size_of::<Ipv4Header>()) as u16),
id: n16::new(id), id: n16::new(id),
flags_fragment: n16::new(0), flags_fragment: n16::new(0),
ttl: 127, ttl: self.ttl,
proto: 0x06, proto: 0x06,
checksum: Checksum { data: 0 }, checksum: Checksum { data: 0 },
src: self.local.0, src: self.local.0,
@ -112,6 +116,18 @@ impl Handle {
} }
} }
#[derive(Copy, Clone)]
enum SettingKind {
Ttl,
ReadTimeout,
WriteTimeout
}
enum Handle {
Tcp(TcpHandle),
Setting(usize, SettingKind),
}
struct Tcpd { struct Tcpd {
scheme_file: File, scheme_file: File,
tcp_file: File, tcp_file: File,
@ -144,21 +160,23 @@ impl Tcpd {
self.handle(&mut packet); self.handle(&mut packet);
if packet.a == (-EWOULDBLOCK) as usize { if packet.a == (-EWOULDBLOCK) as usize {
if let Some(mut handle) = self.handles.get_mut(&packet.b) { if let Some(mut handle) = self.handles.get_mut(&packet.b) {
match a { if let Handle::Tcp(ref mut handle) = *handle {
syscall::number::SYS_DUP => { match a {
packet.a = a; syscall::number::SYS_DUP => {
handle.todo_dup.push_back(packet); packet.a = a;
}, handle.todo_dup.push_back(packet);
syscall::number::SYS_READ => { },
packet.a = a; syscall::number::SYS_READ => {
handle.todo_read.push_back(packet); packet.a = a;
}, handle.todo_read.push_back(packet);
syscall::number::SYS_WRITE => { },
packet.a = a; syscall::number::SYS_WRITE => {
handle.todo_write.push_back(packet); packet.a = a;
}, handle.todo_write.push_back(packet);
_ => { },
self.scheme_file.write(&packet)?; _ => {
self.scheme_file.write(&packet)?;
}
} }
} }
} }
@ -182,46 +200,61 @@ impl Tcpd {
let mut closing = Vec::new(); let mut closing = Vec::new();
let mut found_connection = false; let mut found_connection = false;
for (id, handle) in self.handles.iter_mut() { for (id, handle) in self.handles.iter_mut() {
if handle.state != State::Listen && handle.matches(&ip, &tcp) { if let Handle::Tcp(ref mut handle) = *handle {
found_connection = true; if handle.state != State::Listen && handle.matches(&ip, &tcp) {
found_connection = true;
match handle.state { match handle.state {
State::SynReceived => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq { State::SynReceived => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.state = State::Established; handle.state = State::Established;
}, },
State::SynSent => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_SYN | TCP_ACK && tcp.header.ack_num.get() == handle.seq { State::SynSent => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_SYN | TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.state = State::Established; handle.state = State::Established;
handle.ack = tcp.header.sequence.get() + 1; handle.ack = tcp.header.sequence.get() + 1;
let tcp = handle.create_tcp(TCP_ACK, Vec::new());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?;
},
State::Established => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.ack = tcp.header.sequence.get();
if ! tcp.data.is_empty() {
handle.data.push_back((ip.clone(), tcp.clone()));
handle.ack += tcp.data.len() as u32;
let tcp = handle.create_tcp(TCP_ACK, Vec::new()); let tcp = handle.create_tcp(TCP_ACK, Vec::new());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes()); let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?; self.tcp_file.write(&ip.to_bytes())?;
} else if tcp.header.flags.get() & TCP_FIN == TCP_FIN { },
handle.state = State::CloseWait; State::Established => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.ack = tcp.header.sequence.get();
handle.ack += 1; if ! tcp.data.is_empty() {
handle.data.push_back((ip.clone(), tcp.clone()));
handle.ack += tcp.data.len() as u32;
let tcp = handle.create_tcp(TCP_ACK, Vec::new()); let tcp = handle.create_tcp(TCP_ACK, Vec::new());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes()); let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?; self.tcp_file.write(&ip.to_bytes())?;
} } else if tcp.header.flags.get() & TCP_FIN == TCP_FIN {
}, handle.state = State::CloseWait;
//TODO: Time wait
State::FinWait1 => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq { handle.ack += 1;
handle.ack = tcp.header.sequence.get() + 1;
let tcp = handle.create_tcp(TCP_ACK, Vec::new());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?;
}
},
//TODO: Time wait
State::FinWait1 => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.ack = tcp.header.sequence.get() + 1;
if tcp.header.flags.get() & TCP_FIN == TCP_FIN {
handle.state = State::TimeWait;
let tcp = handle.create_tcp(TCP_ACK, Vec::new());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?;
closing.push(*id);
} else {
handle.state = State::FinWait2;
}
},
State::FinWait2 => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK | TCP_FIN) == TCP_ACK | TCP_FIN && tcp.header.ack_num.get() == handle.seq {
handle.ack = tcp.header.sequence.get() + 1;
if tcp.header.flags.get() & TCP_FIN == TCP_FIN {
handle.state = State::TimeWait; handle.state = State::TimeWait;
let tcp = handle.create_tcp(TCP_ACK, Vec::new()); let tcp = handle.create_tcp(TCP_ACK, Vec::new());
@ -229,89 +262,76 @@ impl Tcpd {
self.tcp_file.write(&ip.to_bytes())?; self.tcp_file.write(&ip.to_bytes())?;
closing.push(*id); closing.push(*id);
},
State::LastAck => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.state = State::Closed;
closing.push(*id);
},
_ => ()
}
while ! handle.todo_read.is_empty() && (! handle.data.is_empty() || handle.read_closed()) {
let mut packet = handle.todo_read.pop_front().unwrap();
let buf = unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) };
if let Some((_ip, tcp)) = handle.data.pop_front() {
let mut i = 0;
while i < buf.len() && i < tcp.data.len() {
buf[i] = tcp.data[i];
i += 1;
}
packet.a = i;
} else { } else {
handle.state = State::FinWait2; packet.a = 0;
} }
},
State::FinWait2 => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK | TCP_FIN) == TCP_ACK | TCP_FIN && tcp.header.ack_num.get() == handle.seq {
handle.ack = tcp.header.sequence.get() + 1;
handle.state = State::TimeWait; self.scheme_file.write(&packet)?;
}
let tcp = handle.create_tcp(TCP_ACK, Vec::new()); if ! handle.todo_write.is_empty() && handle.state == State::Established {
let mut packet = handle.todo_write.pop_front().unwrap();
let buf = unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) };
let tcp = handle.create_tcp(TCP_ACK | TCP_PSH, buf.to_vec());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes()); let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?; let result = self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)));
if result.is_ok() {
closing.push(*id); handle.seq += buf.len() as u32;
},
State::LastAck => if tcp.header.flags.get() & (TCP_SYN | TCP_ACK) == TCP_ACK && tcp.header.ack_num.get() == handle.seq {
handle.state = State::Closed;
closing.push(*id);
},
_ => ()
}
while ! handle.todo_read.is_empty() && (! handle.data.is_empty() || handle.read_closed()) {
let mut packet = handle.todo_read.pop_front().unwrap();
let buf = unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) };
if let Some((_ip, tcp)) = handle.data.pop_front() {
let mut i = 0;
while i < buf.len() && i < tcp.data.len() {
buf[i] = tcp.data[i];
i += 1;
} }
packet.a = i; packet.a = Error::mux(result.and(Ok(buf.len())));
} else {
packet.a = 0; self.scheme_file.write(&packet)?;
} }
self.scheme_file.write(&packet)?; if handle.events & EVENT_READ == EVENT_READ {
} if let Some(&(ref _ip, ref tcp)) = handle.data.get(0) {
self.scheme_file.write(&Packet {
if ! handle.todo_write.is_empty() && handle.state == State::Established { id: 0,
let mut packet = handle.todo_write.pop_front().unwrap(); pid: 0,
let buf = unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }; uid: 0,
gid: 0,
let tcp = handle.create_tcp(TCP_ACK | TCP_PSH, buf.to_vec()); a: syscall::number::SYS_FEVENT,
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes()); b: *id,
let result = self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO))); c: EVENT_READ,
if result.is_ok() { d: tcp.data.len()
handle.seq += buf.len() as u32; })?;
} }
packet.a = Error::mux(result.and(Ok(buf.len())));
self.scheme_file.write(&packet)?;
}
if handle.events & EVENT_READ == EVENT_READ {
if let Some(&(ref _ip, ref tcp)) = handle.data.get(0) {
self.scheme_file.write(&Packet {
id: 0,
pid: 0,
uid: 0,
gid: 0,
a: syscall::number::SYS_FEVENT,
b: *id,
c: EVENT_READ,
d: tcp.data.len()
})?;
} }
} }
} }
} }
for file in closing { for file in closing {
let handle = self.handles.remove(&file).unwrap(); if let Handle::Tcp(handle) = self.handles.remove(&file).unwrap() {
let remove = if let Some(mut port) = self.ports.get_mut(&handle.local.1) {
*port = *port + 1;
*port == 0
} else {
false
};
let remove = if let Some(mut port) = self.ports.get_mut(&handle.local.1) { if remove {
*port = *port + 1; self.ports.remove(&handle.local.1);
*port == 0 }
} else {
false
};
if remove {
self.ports.remove(&handle.local.1);
} }
} }
@ -319,51 +339,56 @@ impl Tcpd {
let mut new_handles = Vec::new(); let mut new_handles = Vec::new();
for (_id, handle) in self.handles.iter_mut() { for (_id, handle) in self.handles.iter_mut() {
if handle.state == State::Listen && handle.matches(&ip, &tcp) { if let Handle::Tcp(ref mut handle) = *handle {
handle.data.push_back((ip.clone(), tcp.clone())); if handle.state == State::Listen && handle.matches(&ip, &tcp) {
handle.data.push_back((ip.clone(), tcp.clone()));
while ! handle.todo_dup.is_empty() && ! handle.data.is_empty() { while ! handle.todo_dup.is_empty() && ! handle.data.is_empty() {
let mut packet = handle.todo_dup.pop_front().unwrap(); let mut packet = handle.todo_dup.pop_front().unwrap();
let (ip, tcp) = handle.data.pop_front().unwrap(); let (ip, tcp) = handle.data.pop_front().unwrap();
let mut new_handle = Handle { let mut new_handle = TcpHandle {
local: handle.local, local: handle.local,
remote: (ip.header.src, tcp.header.src.get()), remote: (ip.header.src, tcp.header.src.get()),
flags: handle.flags, flags: handle.flags,
events: 0, events: 0,
state: State::SynReceived, read_timeout: handle.read_timeout,
seq: self.rng.gen(), write_timeout: handle.write_timeout,
ack: tcp.header.sequence.get() + 1, ttl: handle.ttl,
data: VecDeque::new(), state: State::SynReceived,
todo_dup: VecDeque::new(), seq: self.rng.gen(),
todo_read: VecDeque::new(), ack: tcp.header.sequence.get() + 1,
todo_write: VecDeque::new(), data: VecDeque::new(),
}; todo_dup: VecDeque::new(),
todo_read: VecDeque::new(),
todo_write: VecDeque::new(),
};
let tcp = new_handle.create_tcp(TCP_SYN | TCP_ACK, Vec::new()); let tcp = new_handle.create_tcp(TCP_SYN | TCP_ACK, Vec::new());
let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes()); let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes())?; self.tcp_file.write(&ip.to_bytes())?;
new_handle.seq += 1; new_handle.seq += 1;
handle.data.retain(|&(ref ip, ref tcp)| { handle.data.retain(|&(ref ip, ref tcp)| {
if new_handle.matches(ip, tcp) { if new_handle.matches(ip, tcp) {
false false
} else { } else {
true true
}
});
if let Some(mut port) = self.ports.get_mut(&handle.local.1) {
*port = *port + 1;
} }
});
if let Some(mut port) = self.ports.get_mut(&handle.local.1) { let id = self.next_id;
*port = *port + 1; self.next_id += 1;
packet.a = id;
new_handles.push((packet, Handle::Tcp(new_handle)));
} }
let id = self.next_id;
self.next_id += 1;
packet.a = id;
new_handles.push((packet, new_handle));
} }
} }
} }
@ -401,11 +426,14 @@ impl SchemeMut for Tcpd {
return Err(Error::new(EADDRINUSE)); return Err(Error::new(EADDRINUSE));
} }
let mut handle = Handle { let mut handle = TcpHandle {
local: local, local: local,
remote: remote, remote: remote,
flags: flags, flags: flags,
events: 0, events: 0,
read_timeout: None,
write_timeout: None,
ttl: 64,
state: State::Listen, state: State::Listen,
seq: 0, seq: 0,
ack: 0, ack: 0,
@ -432,93 +460,105 @@ impl SchemeMut for Tcpd {
let id = self.next_id; let id = self.next_id;
self.next_id += 1; self.next_id += 1;
self.handles.insert(id, handle); self.handles.insert(id, Handle::Tcp(handle));
Ok(id) Ok(id)
} }
fn dup(&mut self, file: usize, buf: &[u8]) -> Result<usize> { fn dup(&mut self, file: usize, buf: &[u8]) -> Result<usize> {
let path = str::from_utf8(buf).or(Err(Error::new(EINVAL)))?; let handle = match *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
Handle::Tcp(ref mut handle) => {
let mut new_handle = TcpHandle {
local: handle.local,
remote: handle.remote,
flags: handle.flags,
events: 0,
read_timeout: handle.read_timeout,
write_timeout: handle.write_timeout,
ttl: handle.ttl,
state: handle.state,
seq: handle.seq,
ack: handle.ack,
data: VecDeque::new(),
todo_dup: VecDeque::new(),
todo_read: VecDeque::new(),
todo_write: VecDeque::new(),
};
let handle = { let path = str::from_utf8(buf).or(Err(Error::new(EINVAL)))?;
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?;
let mut new_handle = Handle { if path == "ttl" {
local: handle.local, Handle::Setting(file, SettingKind::Ttl)
remote: handle.remote, } else if path == "read_timeout" {
flags: handle.flags, Handle::Setting(file, SettingKind::ReadTimeout)
events: 0, } else if path == "write_timeout" {
state: handle.state, Handle::Setting(file, SettingKind::WriteTimeout)
seq: handle.seq, } else if path == "listen" {
ack: handle.ack, if handle.is_connected() {
data: VecDeque::new(), return Err(Error::new(EISCONN));
todo_dup: VecDeque::new(), } else if let Some((ip, tcp)) = handle.data.pop_front() {
todo_read: VecDeque::new(), new_handle.remote = (ip.header.src, tcp.header.src.get());
todo_write: VecDeque::new(),
};
if path == "listen" { new_handle.seq = self.rng.gen();
if handle.is_connected() { new_handle.ack = tcp.header.sequence.get() + 1;
return Err(Error::new(EISCONN)); new_handle.state = State::SynReceived;
} else if let Some((ip, tcp)) = handle.data.pop_front() {
new_handle.remote = (ip.header.src, tcp.header.src.get());
new_handle.seq = self.rng.gen(); let tcp = new_handle.create_tcp(TCP_SYN | TCP_ACK, Vec::new());
new_handle.ack = tcp.header.sequence.get() + 1; let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes());
new_handle.state = State::SynReceived; self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO))).and(Ok(buf.len()))?;
let tcp = new_handle.create_tcp(TCP_SYN | TCP_ACK, Vec::new()); new_handle.seq += 1;
let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO))).and(Ok(buf.len()))?;
new_handle.seq += 1;
} else {
return Err(Error::new(EWOULDBLOCK));
}
handle.data.retain(|&(ref ip, ref tcp)| {
if new_handle.matches(ip, tcp) {
false
} else { } else {
true return Err(Error::new(EWOULDBLOCK));
} }
});
} else if path.is_empty() {
new_handle.data = handle.data.clone();
} else if handle.is_connected() {
return Err(Error::new(EISCONN));
} else {
new_handle.remote = parse_socket(path);
if new_handle.is_connected() {
new_handle.seq = self.rng.gen();
new_handle.ack = 0;
new_handle.state = State::SynSent;
handle.data.retain(|&(ref ip, ref tcp)| { handle.data.retain(|&(ref ip, ref tcp)| {
if new_handle.matches(ip, tcp) { if new_handle.matches(ip, tcp) {
new_handle.data.push_back((ip.clone(), tcp.clone()));
false false
} else { } else {
true true
} }
}); });
let tcp = new_handle.create_tcp(TCP_SYN, Vec::new()); Handle::Tcp(new_handle)
let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes()); } else if path.is_empty() {
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO))).and(Ok(buf.len()))?; new_handle.data = handle.data.clone();
Handle::Tcp(new_handle)
} else if handle.is_connected() {
return Err(Error::new(EISCONN));
} else { } else {
return Err(Error::new(EINVAL)); new_handle.remote = parse_socket(path);
if new_handle.is_connected() {
new_handle.seq = self.rng.gen();
new_handle.ack = 0;
new_handle.state = State::SynSent;
handle.data.retain(|&(ref ip, ref tcp)| {
if new_handle.matches(ip, tcp) {
new_handle.data.push_back((ip.clone(), tcp.clone()));
false
} else {
true
}
});
let tcp = new_handle.create_tcp(TCP_SYN, Vec::new());
let ip = new_handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO))).and(Ok(buf.len()))?;
Handle::Tcp(new_handle)
} else {
return Err(Error::new(EINVAL));
}
} }
},
Handle::Setting(file, kind) => {
Handle::Setting(file, kind)
} }
new_handle
}; };
if let Some(mut port) = self.ports.get_mut(&handle.local.1) {
*port = *port + 1;
}
let id = self.next_id; let id = self.next_id;
self.next_id += 1; self.next_id += 1;
@ -528,82 +568,159 @@ impl SchemeMut for Tcpd {
} }
fn read(&mut self, file: usize, buf: &mut [u8]) -> Result<usize> { fn read(&mut self, file: usize, buf: &mut [u8]) -> Result<usize> {
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?; let (file, kind) = match *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
Handle::Tcp(ref mut handle) => {
if ! handle.is_connected() {
return Err(Error::new(ENOTCONN));
} else if let Some((_ip, tcp)) = handle.data.pop_front() {
let mut i = 0;
while i < buf.len() && i < tcp.data.len() {
buf[i] = tcp.data[i];
i += 1;
}
if ! handle.is_connected() { return Ok(i);
Err(Error::new(ENOTCONN)) } else if handle.flags & O_NONBLOCK == O_NONBLOCK || handle.read_closed() {
} else if let Some((_ip, tcp)) = handle.data.pop_front() { return Ok(0);
let mut i = 0; } else {
while i < buf.len() && i < tcp.data.len() { return Err(Error::new(EWOULDBLOCK));
buf[i] = tcp.data[i]; }
i += 1; },
Handle::Setting(file, kind) => {
(file, kind)
} }
};
Ok(i) if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
} else if handle.flags & O_NONBLOCK == O_NONBLOCK || handle.read_closed() { let read_timeout = |timeout: &Option<TimeSpec>, buf: &mut [u8]| -> Result<usize> {
Ok(0) if let Some(ref timespec) = *timeout {
timespec.deref().read(buf).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))
} else {
Ok(0)
}
};
match kind {
SettingKind::Ttl => {
if let Some(mut ttl) = buf.get_mut(0) {
*ttl = handle.ttl;
Ok(1)
} else {
Ok(0)
}
},
SettingKind::ReadTimeout => {
read_timeout(&handle.read_timeout, buf)
},
SettingKind::WriteTimeout => {
read_timeout(&handle.write_timeout, buf)
}
}
} else { } else {
Err(Error::new(EWOULDBLOCK)) Err(Error::new(EBADF))
} }
} }
fn write(&mut self, file: usize, buf: &[u8]) -> Result<usize> { fn write(&mut self, file: usize, buf: &[u8]) -> Result<usize> {
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?; let (file, kind) = match *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
Handle::Tcp(ref mut handle) => {
if ! handle.is_connected() {
return Err(Error::new(ENOTCONN));
} else if buf.len() >= 65507 {
return Err(Error::new(EMSGSIZE));
} else {
match handle.state {
State::Established => {
let tcp = handle.create_tcp(TCP_ACK | TCP_PSH, buf.to_vec());
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
handle.seq += buf.len() as u32;
return Ok(buf.len());
},
_ => {
return Err(Error::new(EWOULDBLOCK));
}
}
}
},
Handle::Setting(file, kind) => {
(file, kind)
}
};
if ! handle.is_connected() { if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
Err(Error::new(ENOTCONN)) let write_timeout = |timeout: &mut Option<TimeSpec>, buf: &[u8]| -> Result<usize> {
} else if buf.len() >= 65507 { if buf.len() >= mem::size_of::<TimeSpec>() {
Err(Error::new(EMSGSIZE)) let mut timespec = TimeSpec::default();
} else { let count = timespec.deref_mut().write(buf).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
match handle.state { *timeout = Some(timespec);
State::Established => { Ok(count)
let tcp = handle.create_tcp(TCP_ACK | TCP_PSH, buf.to_vec()); } else {
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes()); *timeout = None;
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?; Ok(0)
handle.seq += buf.len() as u32; }
Ok(buf.len()) };
match kind {
SettingKind::Ttl => {
if let Some(ttl) = buf.get(0) {
handle.ttl = *ttl;
Ok(1)
} else {
Ok(0)
}
}, },
_ => { SettingKind::ReadTimeout => {
Err(Error::new(EWOULDBLOCK)) write_timeout(&mut handle.read_timeout, buf)
},
SettingKind::WriteTimeout => {
write_timeout(&mut handle.write_timeout, buf)
} }
} }
} else {
Err(Error::new(EBADF))
} }
} }
fn fcntl(&mut self, file: usize, cmd: usize, arg: usize) -> Result<usize> { fn fcntl(&mut self, file: usize, cmd: usize, arg: usize) -> Result<usize> {
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?; if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
match cmd {
match cmd { F_GETFL => Ok(handle.flags),
F_GETFL => Ok(handle.flags), F_SETFL => {
F_SETFL => { handle.flags = arg & ! O_ACCMODE;
handle.flags = arg & ! O_ACCMODE; Ok(0)
Ok(0) },
}, _ => Err(Error::new(EINVAL))
_ => Err(Error::new(EINVAL)) }
} else {
Err(Error::new(EBADF))
} }
} }
fn fevent(&mut self, file: usize, flags: usize) -> Result<usize> { fn fevent(&mut self, file: usize, flags: usize) -> Result<usize> {
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?; if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
handle.events = flags;
handle.events = flags; Ok(file)
} else {
Ok(file) Err(Error::new(EBADF))
}
} }
fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> { fn fpath(&mut self, file: usize, buf: &mut [u8]) -> Result<usize> {
let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?; if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
let path_string = format!("udp:{}:{}/{}:{}", handle.remote.0.to_string(), handle.remote.1, handle.local.0.to_string(), handle.local.1);
let path = path_string.as_bytes();
let path_string = format!("tcp:{}:{}/{}:{}", handle.remote.0.to_string(), handle.remote.1, handle.local.0.to_string(), handle.local.1); let mut i = 0;
let path = path_string.as_bytes(); while i < buf.len() && i < path.len() {
buf[i] = path[i];
i += 1;
}
let mut i = 0; Ok(i)
while i < buf.len() && i < path.len() { } else {
buf[i] = path[i]; Err(Error::new(EBADF))
i += 1;
} }
Ok(i)
} }
fn fsync(&mut self, file: usize) -> Result<usize> { fn fsync(&mut self, file: usize) -> Result<usize> {
@ -614,49 +731,51 @@ impl SchemeMut for Tcpd {
fn close(&mut self, file: usize) -> Result<usize> { fn close(&mut self, file: usize) -> Result<usize> {
let closed = { let closed = {
let mut handle = self.handles.get_mut(&file).ok_or(Error::new(EBADF))?; if let Handle::Tcp(ref mut handle) = *self.handles.get_mut(&file).ok_or(Error::new(EBADF))? {
handle.data.clear();
handle.data.clear(); match handle.state {
State::SynReceived | State::Established => {
handle.state = State::FinWait1;
match handle.state { let tcp = handle.create_tcp(TCP_FIN | TCP_ACK, Vec::new());
State::SynReceived | State::Established => { let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
handle.state = State::FinWait1; self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
let tcp = handle.create_tcp(TCP_FIN | TCP_ACK, Vec::new()); handle.seq += 1;
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
handle.seq += 1; false
},
State::CloseWait => {
handle.state = State::LastAck;
false let tcp = handle.create_tcp(TCP_FIN | TCP_ACK, Vec::new());
}, let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
State::CloseWait => { self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
handle.state = State::LastAck;
let tcp = handle.create_tcp(TCP_FIN | TCP_ACK, Vec::new()); handle.seq += 1;
let ip = handle.create_ip(self.rng.gen(), tcp.to_bytes());
self.tcp_file.write(&ip.to_bytes()).map_err(|err| Error::new(err.raw_os_error().unwrap_or(EIO)))?;
handle.seq += 1; false
},
false _ => true
}, }
_ => true } else {
true
} }
}; };
if closed { if closed {
let handle = self.handles.remove(&file).ok_or(Error::new(EBADF))?; if let Handle::Tcp(handle) = self.handles.remove(&file).ok_or(Error::new(EBADF))? {
let remove = if let Some(mut port) = self.ports.get_mut(&handle.local.1) {
*port = *port + 1;
*port == 0
} else {
false
};
let remove = if let Some(mut port) = self.ports.get_mut(&handle.local.1) { if remove {
*port = *port + 1; self.ports.remove(&handle.local.1);
*port == 0 }
} else {
false
};
if remove {
self.ports.remove(&handle.local.1);
} }
} }