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

Cleanup of panics in network schemes

Browse source
This commit is contained in:
Jeremy Soller 2017-02-07 20:23:41 -07:00
parent 1346d8a181
commit 7785ddd99b
4 changed files with 233 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
schemes/ethernetd/src/main.rs
View file

@ -7,6 +7,7 @@ use std::cell::RefCell;
use std::fs::File;
use std::io::{Result, Read, Write};
use std::os::unix::io::FromRawFd;
use std::process;
use std::rc::Rc;
use syscall::{Packet, SchemeMut, EWOULDBLOCK};
@ -15,17 +16,10 @@ use scheme::EthernetScheme;
mod scheme;
fn main() {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
let network_fd = syscall::open("network:", syscall::O_RDWR | syscall::O_NONBLOCK).expect("ethernetd: failed to open network");
fn daemon(network_fd: usize, socket_fd: usize) {
let network = unsafe { File::from_raw_fd(network_fd) };
let socket_fd = syscall::open(":ethernet", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK).expect("ethernetd: failed to create ethernet scheme");
let socket = Rc::new(RefCell::new(unsafe { File::from_raw_fd(socket_fd) }));
let scheme = Rc::new(RefCell::new(EthernetScheme::new(network)));
let todo = Rc::new(RefCell::new(Vec::<Packet>::new()));
let mut event_queue = EventQueue::<()>::new().expect("ethernetd: failed to create event queue");
@ -90,5 +84,25 @@ fn main() {
event_queue.trigger_all(0).expect("ethernetd: failed to trigger events");
event_queue.run().expect("ethernetd: failed to run event loop");
}
fn main() {
match syscall::open("network:", syscall::O_RDWR | syscall::O_NONBLOCK) {
Ok(network_fd) => match syscall::open(":ethernet", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK) {
Ok(socket_fd) => {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
daemon(network_fd, socket_fd);
}
},
Err(err) => {
println!("ethernetd: failed to create ethernet scheme: {}", err);
process::exit(1);
}
},
Err(err) => {
println!("ethernetd: failed to open network: {}", err);
process::exit(1);
}
}
}

35
schemes/ipd/src/main.rs
View file

@ -9,8 +9,8 @@ use std::collections::{BTreeMap, VecDeque};
use std::fs::File;
use std::io::{self, Read, Write};
use std::os::unix::io::FromRawFd;
use std::{process, slice, str};
use std::rc::Rc;
use std::{slice, str};
use syscall::data::Packet;
use syscall::error::{Error, Result, EACCES, EADDRNOTAVAIL, EBADF, EIO, EINVAL, ENOENT, EWOULDBLOCK};
use syscall::flag::{EVENT_READ, O_NONBLOCK};
@ -255,10 +255,7 @@ impl SchemeMut for Ipd {
}
}
fn main() {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
let scheme_fd = syscall::open(":ip", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK).expect("ipd: failed to create :ip");
fn daemon(arp_fd: usize, ip_fd: usize, scheme_fd: usize) {
let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
let ipd = Rc::new(RefCell::new(Ipd::new(scheme_file)));
@ -267,8 +264,6 @@ fn main() {
//TODO: Multiple interfaces
{
let arp_fd = syscall::open("ethernet:806", syscall::O_RDWR | syscall::O_NONBLOCK).expect("ipd: failed to open ethernet:806");
let ip_fd = syscall::open("ethernet:800", syscall::O_RDWR | syscall::O_NONBLOCK).expect("ipd: failed to open ethernet:800");
let if_id = {
let mut ipd = ipd.borrow_mut();
let if_id = ipd.interfaces.len();
@ -314,5 +309,31 @@ fn main() {
event_queue.trigger_all(0).expect("ipd: failed to trigger event queue");
event_queue.run().expect("ipd: failed to run event queue");
}
fn main() {
match syscall::open("ethernet:806", syscall::O_RDWR | syscall::O_NONBLOCK) {
Ok(arp_fd) => match syscall::open("ethernet:800", syscall::O_RDWR | syscall::O_NONBLOCK) {
Ok(ip_fd) => match syscall::open(":ip", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK) {
Ok(scheme_fd) => {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
daemon(arp_fd, ip_fd, scheme_fd);
}
},
Err(err) => {
println!("ipd: failed to create ip scheme: {}", err);
process::exit(1);
}
},
Err(err) => {
println!("ipd: failed to open ethernet:800: {}", err);
process::exit(1);
}
},
Err(err) => {
println!("ipd: failed to open ethernet:806: {}", err);
process::exit(1);
}
}
}

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

@ -8,7 +8,7 @@ use std::collections::{BTreeMap, VecDeque};
use std::cell::RefCell;
use std::fs::File;
use std::io::{self, Read, Write};
use std::{mem, slice, str};
use std::{mem, process, slice, str};
use std::ops::{Deref, DerefMut};
use std::os::unix::io::FromRawFd;
use std::rc::Rc;
@ -783,14 +783,9 @@ impl SchemeMut for Tcpd {
}
}
fn main() {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
let scheme_fd = syscall::open(":tcp", O_RDWR | O_CREAT | O_NONBLOCK).expect("tcpd: failed to create :tcp");
let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
let tcp_fd = syscall::open("ip:6", O_RDWR | O_NONBLOCK).expect("tcpd: failed to open ip:6");
fn daemon(tcp_fd: usize, scheme_fd: usize) {
let tcp_file = unsafe { File::from_raw_fd(tcp_fd) };
let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
let tcpd = Rc::new(RefCell::new(Tcpd::new(scheme_file, tcp_file)));
@ -810,5 +805,25 @@ fn main() {
event_queue.trigger_all(0).expect("tcpd: failed to trigger event queue");
event_queue.run().expect("tcpd: failed to run event queue");
}
fn main() {
match syscall::open("ip:6", O_RDWR | O_NONBLOCK) {
Ok(tcp_fd) => match syscall::open(":tcp", O_RDWR | O_CREAT | O_NONBLOCK) {
Ok(scheme_fd) => {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
daemon(tcp_fd, scheme_fd);
}
},
Err(err) => {
println!("tcpd: failed to create tcp scheme: {}", err);
process::exit(1);
}
},
Err(err) => {
println!("tcpd: failed to open ip:6: {}", err);
process::exit(1);
}
}
}

32
schemes/udpd/src/main.rs
View file

@ -8,7 +8,7 @@ use std::collections::{BTreeMap, VecDeque};
use std::cell::RefCell;
use std::fs::File;
use std::io::{self, Read, Write};
use std::{mem, slice, str};
use std::{mem, process, slice, str};
use std::ops::{Deref, DerefMut};
use std::os::unix::io::FromRawFd;
use std::rc::Rc;
@ -450,15 +450,9 @@ impl SchemeMut for Udpd {
Ok(0)
}
}
fn main() {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
let scheme_fd = syscall::open(":udp", O_RDWR | O_CREAT | O_NONBLOCK).expect("udpd: failed to create :udp");
let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
let udp_fd = syscall::open("ip:11", O_RDWR | O_NONBLOCK).expect("udpd: failed to open ip:11");
fn daemon(udp_fd: usize, scheme_fd: usize) {
let udp_file = unsafe { File::from_raw_fd(udp_fd) };
let scheme_file = unsafe { File::from_raw_fd(scheme_fd) };
let udpd = Rc::new(RefCell::new(Udpd::new(scheme_file, udp_file)));
@ -478,5 +472,25 @@ fn main() {
event_queue.trigger_all(0).expect("udpd: failed to trigger event queue");
event_queue.run().expect("udpd: failed to run event queue");
}
fn main() {
match syscall::open("ip:11", O_RDWR | O_NONBLOCK) {
Ok(udp_fd) => match syscall::open(":udp", O_RDWR | O_CREAT | O_NONBLOCK) {
Ok(scheme_fd) => {
// Daemonize
if unsafe { syscall::clone(0).unwrap() } == 0 {
daemon(udp_fd, scheme_fd);
}
},
Err(err) => {
println!("udpd: failed to create udp scheme: {}", err);
process::exit(1);
}
},
Err(err) => {
println!("udpd: failed to open ip:11: {}", err);
process::exit(1);
}
}
}