redox/schemes/ethernetd/src/main.rs

extern crate event;
extern crate netutils;
extern crate syscall;

use event::EventQueue;
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};

use scheme::EthernetScheme;

mod scheme;

fn daemon(network_fd: usize, socket_fd: usize) {
    let network = unsafe { File::from_raw_fd(network_fd) };
    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");

    let socket_net = socket.clone();
    let scheme_net = scheme.clone();
    let todo_net = todo.clone();
    event_queue.add(network_fd, move |_count: usize| -> Result<Option<()>> {
        if scheme_net.borrow_mut().input()? > 0 {
            let mut todo = todo_net.borrow_mut();
            let mut i = 0;
            while i < todo.len() {
                let a = todo[i].a;
                scheme_net.borrow_mut().handle(&mut todo[i]);
                if todo[i].a == (-EWOULDBLOCK) as usize {
                    todo[i].a = a;
                    i += 1;
                } else {
                    socket_net.borrow_mut().write(&mut todo[i])?;
                    todo.remove(i);
                }
            }

            for (id, handle) in scheme_net.borrow_mut().handles.iter() {
                if let Some(frame) = handle.frames.get(0) {
                    socket_net.borrow_mut().write(&Packet {
                        id: 0,
                        pid: 0,
                        uid: 0,
                        gid: 0,
                        a: syscall::number::SYS_FEVENT,
                        b: *id,
                        c: syscall::flag::EVENT_READ,
                        d: frame.data.len()
                    })?;
                }
            }
        }
        Ok(None)
    }).expect("ethernetd: failed to listen for network events");

    event_queue.add(socket_fd, move |_count: usize| -> Result<Option<()>> {
        loop {
            let mut packet = Packet::default();
            if socket.borrow_mut().read(&mut packet)? == 0 {
                break;
            }

            let a = packet.a;
            scheme.borrow_mut().handle(&mut packet);
            if packet.a == (-EWOULDBLOCK) as usize {
                packet.a = a;
                todo.borrow_mut().push(packet);
            } else {
                socket.borrow_mut().write(&mut packet)?;
            }
        }

        Ok(None)
    }).expect("ethernetd: failed to listen for scheme events");

    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) => {
            // Daemonize
            if unsafe { syscall::clone(0).unwrap() } == 0 {
                match syscall::open(":ethernet", syscall::O_RDWR | syscall::O_CREAT | syscall::O_NONBLOCK) {
                    Ok(socket_fd) => {
                        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);
        }
    }
}