Orbital (#16)
* Port previous ethernet scheme * Add ipd * Fix initfs rebuilds, use QEMU user networking addresses in ipd * Add tcp/udp, netutils, dns, and network config * Add fsync to network driver * Add dns, router, subnet by default * Fix e1000 driver. Make ethernet and IP non-blocking to avoid deadlocks * Add orbital server, WIP * Add futex * Add orbutils and orbital * Update libstd, orbutils, and orbital Move ANSI key encoding to vesad * Add orbital assets * Update orbital * Update to add login manager * Add blocking primitives, block for most things except waitpid, update orbital * Wait in waitpid and IRQ, improvements for other waits * Fevent in root scheme * WIP: Switch to using fevent * Reorganize * Event based e1000d driver * Superuser-only access to some network schemes, display, and disk * Superuser root and irq schemes * Fix orbital
This commit is contained in:
Jeremy Soller
GitHub
parent
372d44f88c
commit
224c43f761
92 changed files with 3415 additions and 473 deletions
167
schemes/udpd/src/common.rs
Normal file
167
schemes/udpd/src/common.rs
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
use std::{mem, slice, u8, u16};
|
||||
|
||||
pub static mut IP_ADDR: Ipv4Addr = Ipv4Addr { bytes: [10, 0, 2, 15] };
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[allow(non_camel_case_types)]
|
||||
#[repr(packed)]
|
||||
pub struct n16(u16);
|
||||
|
||||
impl n16 {
|
||||
pub fn new(value: u16) -> Self {
|
||||
n16(value.to_be())
|
||||
}
|
||||
|
||||
pub fn get(&self) -> u16 {
|
||||
u16::from_be(self.0)
|
||||
}
|
||||
|
||||
pub fn set(&mut self, value: u16) {
|
||||
self.0 = value.to_be();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Ipv4Addr {
|
||||
pub bytes: [u8; 4],
|
||||
}
|
||||
|
||||
impl Ipv4Addr {
|
||||
pub fn equals(&self, other: Self) -> bool {
|
||||
for i in 0..4 {
|
||||
if self.bytes[i] != other.bytes[i] {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub fn from_str(string: &str) -> Self {
|
||||
let mut addr = Ipv4Addr { bytes: [0, 0, 0, 0] };
|
||||
|
||||
let mut i = 0;
|
||||
for part in string.split('.') {
|
||||
let octet = part.parse::<u8>().unwrap_or(0);
|
||||
match i {
|
||||
0 => addr.bytes[0] = octet,
|
||||
1 => addr.bytes[1] = octet,
|
||||
2 => addr.bytes[2] = octet,
|
||||
3 => addr.bytes[3] = octet,
|
||||
_ => break,
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
|
||||
addr
|
||||
}
|
||||
|
||||
pub fn to_string(&self) -> String {
|
||||
let mut string = String::new();
|
||||
|
||||
for i in 0..4 {
|
||||
if i > 0 {
|
||||
string = string + ".";
|
||||
}
|
||||
string = string + &format!("{}", self.bytes[i]);
|
||||
}
|
||||
|
||||
string
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Checksum {
|
||||
pub data: u16,
|
||||
}
|
||||
|
||||
impl Checksum {
|
||||
pub unsafe fn check(&self, mut ptr: usize, mut len: usize) -> bool {
|
||||
let mut sum: usize = 0;
|
||||
while len > 1 {
|
||||
sum += *(ptr as *const u16) as usize;
|
||||
len -= 2;
|
||||
ptr += 2;
|
||||
}
|
||||
|
||||
if len > 0 {
|
||||
sum += *(ptr as *const u8) as usize;
|
||||
}
|
||||
|
||||
while (sum >> 16) > 0 {
|
||||
sum = (sum & 0xFFFF) + (sum >> 16);
|
||||
}
|
||||
|
||||
sum == 0xFFFF
|
||||
}
|
||||
|
||||
pub unsafe fn calculate(&mut self, ptr: usize, len: usize) {
|
||||
self.data = 0;
|
||||
|
||||
let sum = Checksum::sum(ptr, len);
|
||||
|
||||
self.data = Checksum::compile(sum);
|
||||
}
|
||||
|
||||
pub unsafe fn sum(mut ptr: usize, mut len: usize) -> usize {
|
||||
let mut sum = 0;
|
||||
|
||||
while len > 1 {
|
||||
sum += *(ptr as *const u16) as usize;
|
||||
len -= 2;
|
||||
ptr += 2;
|
||||
}
|
||||
|
||||
if len > 0 {
|
||||
sum += *(ptr as *const u8) as usize;
|
||||
}
|
||||
|
||||
sum
|
||||
}
|
||||
|
||||
pub fn compile(mut sum: usize) -> u16 {
|
||||
while (sum >> 16) > 0 {
|
||||
sum = (sum & 0xFFFF) + (sum >> 16);
|
||||
}
|
||||
|
||||
0xFFFF - (sum as u16)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(packed)]
|
||||
pub struct UdpHeader {
|
||||
pub src: n16,
|
||||
pub dst: n16,
|
||||
pub len: n16,
|
||||
pub checksum: Checksum,
|
||||
}
|
||||
|
||||
pub struct Udp {
|
||||
pub header: UdpHeader,
|
||||
pub data: Vec<u8>,
|
||||
}
|
||||
|
||||
impl Udp {
|
||||
pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
|
||||
if bytes.len() >= mem::size_of::<UdpHeader>() {
|
||||
unsafe {
|
||||
Option::Some(Udp {
|
||||
header: *(bytes.as_ptr() as *const UdpHeader),
|
||||
data: bytes[mem::size_of::<UdpHeader>()..bytes.len()].to_vec(),
|
||||
})
|
||||
}
|
||||
} else {
|
||||
Option::None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_bytes(&self) -> Vec<u8> {
|
||||
unsafe {
|
||||
let header_ptr: *const UdpHeader = &self.header;
|
||||
let mut ret = Vec::from(slice::from_raw_parts(header_ptr as *const u8,
|
||||
mem::size_of::<UdpHeader>()));
|
||||
ret.extend_from_slice(&self.data);
|
||||
ret
|
||||
}
|
||||
}
|
||||
}
|
||||
30
schemes/udpd/src/main.rs
Normal file
30
schemes/udpd/src/main.rs
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
#![feature(rand)]
|
||||
|
||||
extern crate resource_scheme;
|
||||
extern crate syscall;
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::{Read, Write};
|
||||
use std::thread;
|
||||
|
||||
use resource_scheme::ResourceScheme;
|
||||
use syscall::Packet;
|
||||
|
||||
use scheme::UdpScheme;
|
||||
|
||||
pub mod common;
|
||||
pub mod resource;
|
||||
pub mod scheme;
|
||||
|
||||
fn main() {
|
||||
thread::spawn(move || {
|
||||
let mut socket = File::create(":udp").expect("udpd: failed to create udp scheme");
|
||||
let scheme = UdpScheme;
|
||||
loop {
|
||||
let mut packet = Packet::default();
|
||||
socket.read(&mut packet).expect("udpd: failed to read events from udp scheme");
|
||||
scheme.handle(&mut packet);
|
||||
socket.write(&packet).expect("udpd: failed to write responses to udp scheme");
|
||||
}
|
||||
});
|
||||
}
|
||||
114
schemes/udpd/src/resource.rs
Normal file
114
schemes/udpd/src/resource.rs
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
use std::{cmp, mem};
|
||||
|
||||
use resource_scheme::Resource;
|
||||
use syscall;
|
||||
use syscall::error::*;
|
||||
|
||||
use common::{n16, Ipv4Addr, Checksum, IP_ADDR, Udp, UdpHeader};
|
||||
|
||||
/// UDP resource
|
||||
pub struct UdpResource {
|
||||
pub ip: usize,
|
||||
pub data: Vec<u8>,
|
||||
pub peer_addr: Ipv4Addr,
|
||||
pub peer_port: u16,
|
||||
pub host_port: u16,
|
||||
}
|
||||
|
||||
impl Resource for UdpResource {
|
||||
fn dup(&self) -> Result<Box<UdpResource>> {
|
||||
match syscall::dup(self.ip) {
|
||||
Ok(ip) => {
|
||||
Ok(Box::new(UdpResource {
|
||||
ip: ip,
|
||||
data: self.data.clone(),
|
||||
peer_addr: self.peer_addr,
|
||||
peer_port: self.peer_port,
|
||||
host_port: self.host_port,
|
||||
}))
|
||||
}
|
||||
Err(err) => Err(err),
|
||||
}
|
||||
}
|
||||
|
||||
fn path(&self, buf: &mut [u8]) -> Result<usize> {
|
||||
let path_string = format!("udp:{}:{}/{}", self.peer_addr.to_string(), self.peer_port, self.host_port);
|
||||
let path = path_string.as_bytes();
|
||||
|
||||
for (b, p) in buf.iter_mut().zip(path.iter()) {
|
||||
*b = *p;
|
||||
}
|
||||
|
||||
Ok(cmp::min(buf.len(), path.len()))
|
||||
}
|
||||
|
||||
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
|
||||
if ! self.data.is_empty() {
|
||||
let mut bytes: Vec<u8> = Vec::new();
|
||||
mem::swap(&mut self.data, &mut bytes);
|
||||
|
||||
// TODO: Allow splitting
|
||||
let mut i = 0;
|
||||
while i < buf.len() && i < bytes.len() {
|
||||
buf[i] = bytes[i];
|
||||
i += 1;
|
||||
}
|
||||
|
||||
return Ok(i);
|
||||
}
|
||||
|
||||
loop {
|
||||
let mut bytes = [0; 65536];
|
||||
let count = try!(syscall::read(self.ip, &mut bytes));
|
||||
|
||||
if let Some(datagram) = Udp::from_bytes(&bytes[..count]) {
|
||||
if datagram.header.dst.get() == self.host_port &&
|
||||
datagram.header.src.get() == self.peer_port {
|
||||
// TODO: Allow splitting
|
||||
let mut i = 0;
|
||||
while i < buf.len() && i < datagram.data.len() {
|
||||
buf[i] = datagram.data[i];
|
||||
i += 1;
|
||||
}
|
||||
|
||||
return Ok(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn write(&mut self, buf: &[u8]) -> Result<usize> {
|
||||
let mut udp = Udp {
|
||||
header: UdpHeader {
|
||||
src: n16::new(self.host_port),
|
||||
dst: n16::new(self.peer_port),
|
||||
len: n16::new((mem::size_of::<UdpHeader>() + buf.len()) as u16),
|
||||
checksum: Checksum { data: 0 },
|
||||
},
|
||||
data: Vec::from(buf),
|
||||
};
|
||||
|
||||
unsafe {
|
||||
let proto = n16::new(0x11);
|
||||
let datagram_len = n16::new((mem::size_of::<UdpHeader>() + udp.data.len()) as u16);
|
||||
udp.header.checksum.data =
|
||||
Checksum::compile(Checksum::sum((&IP_ADDR as *const Ipv4Addr) as usize,
|
||||
mem::size_of::<Ipv4Addr>()) +
|
||||
Checksum::sum((&self.peer_addr as *const Ipv4Addr) as usize,
|
||||
mem::size_of::<Ipv4Addr>()) +
|
||||
Checksum::sum((&proto as *const n16) as usize,
|
||||
mem::size_of::<n16>()) +
|
||||
Checksum::sum((&datagram_len as *const n16) as usize,
|
||||
mem::size_of::<n16>()) +
|
||||
Checksum::sum((&udp.header as *const UdpHeader) as usize,
|
||||
mem::size_of::<UdpHeader>()) +
|
||||
Checksum::sum(udp.data.as_ptr() as usize, udp.data.len()));
|
||||
}
|
||||
|
||||
syscall::write(self.ip, &udp.to_bytes()).and(Ok(buf.len()))
|
||||
}
|
||||
|
||||
fn sync(&mut self) -> Result<usize> {
|
||||
syscall::fsync(self.ip)
|
||||
}
|
||||
}
|
||||
69
schemes/udpd/src/scheme.rs
Normal file
69
schemes/udpd/src/scheme.rs
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
use std::rand;
|
||||
use std::{str, u16};
|
||||
|
||||
use resource_scheme::ResourceScheme;
|
||||
use syscall;
|
||||
use syscall::error::{Error, Result, ENOENT, EINVAL};
|
||||
use syscall::flag::O_RDWR;
|
||||
|
||||
use common::{Ipv4Addr, Udp};
|
||||
use resource::UdpResource;
|
||||
|
||||
/// UDP UdpScheme
|
||||
pub struct UdpScheme;
|
||||
|
||||
impl ResourceScheme<UdpResource> for UdpScheme {
|
||||
fn open_resource(&self, url: &[u8], _flags: usize, _uid: u32, _gid: u32) -> Result<Box<UdpResource>> {
|
||||
let path = try!(str::from_utf8(url).or(Err(Error::new(EINVAL))));
|
||||
let mut parts = path.split('/');
|
||||
let remote = parts.next().unwrap_or("");
|
||||
let path = parts.next().unwrap_or("");
|
||||
|
||||
// Check host and port vs path
|
||||
if remote.is_empty() {
|
||||
let host_port = path.parse::<u16>().unwrap_or(0);
|
||||
if host_port > 0 {
|
||||
while let Ok(ip) = syscall::open("ip:/11", O_RDWR) {
|
||||
let mut bytes = [0; 65536];
|
||||
if let Ok(count) = syscall::read(ip, &mut bytes) {
|
||||
if let Some(datagram) = Udp::from_bytes(&bytes[..count]) {
|
||||
if datagram.header.dst.get() == host_port {
|
||||
let mut path = [0; 256];
|
||||
if let Ok(path_count) = syscall::fpath(ip, &mut path) {
|
||||
let ip_reference = unsafe { str::from_utf8_unchecked(&path[.. path_count]) }.split(':').nth(1).unwrap_or("");
|
||||
let peer_addr = ip_reference.split('/').next().unwrap_or("").split(':').next().unwrap_or("");
|
||||
|
||||
return Ok(Box::new(UdpResource {
|
||||
ip: ip,
|
||||
data: datagram.data,
|
||||
peer_addr: Ipv4Addr::from_str(peer_addr),
|
||||
peer_port: datagram.header.src.get(),
|
||||
host_port: host_port,
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let mut remote_parts = remote.split(':');
|
||||
let peer_addr = remote_parts.next().unwrap_or("");
|
||||
let peer_port = remote_parts.next().unwrap_or("").parse::<u16>().unwrap_or(0);
|
||||
if peer_port > 0 {
|
||||
let host_port = path.parse::<u16>().unwrap_or((rand() % 32768 + 32768) as u16);
|
||||
if let Ok(ip) = syscall::open(&format!("ip:{}/11", peer_addr), O_RDWR) {
|
||||
return Ok(Box::new(UdpResource {
|
||||
ip: ip,
|
||||
data: Vec::new(),
|
||||
peer_addr: Ipv4Addr::from_str(peer_addr),
|
||||
peer_port: peer_port as u16,
|
||||
host_port: host_port,
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Err(Error::new(ENOENT))
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue